home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / FSM.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  31.9 KB  |  904 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT FSM;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __FSM__}
  30. {$SETC __FSM__ := 1}
  31.  
  32. {$I+}
  33. {$SETC FSMIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __FILES__}
  38. {$I Files.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43. {    OSUtils.p                                                    }
  44. {        Memory.p                                                }
  45.  
  46. {$PUSH}
  47. {$ALIGN MAC68K}
  48. {$LibExport+}
  49.  
  50. CONST
  51. {    The new volume mount flags }
  52.     volMountInteractBit            = 15;                            { Input to VolumeMount: If set, it's OK for the file system }
  53.     volMountInteractMask        = $8000;                        { to perform user interaction to mount the volume }
  54.     volMountChangedBit            = 14;                            { Output from VoumeMount: If set, the volume was mounted, but }
  55.     volMountChangedMask            = $4000;                        { the volume mounting information record needs to be updated. }
  56.     volMountFSReservedMask        = $00ff;                        { bits 0-7 are defined by each file system for its own use }
  57.     volMountSysReservedMask        = $ff00;                        { bits 8-15 are reserved for Apple system use }
  58.  
  59. {
  60.  * The new volume mount info record
  61.  }
  62.  
  63. TYPE
  64.     VolumeMountInfoHeader = RECORD
  65.         length:                    INTEGER;                                { length of location data (including self) }
  66.         media:                    VolumeType;                                { type of media (must be registered with Apple) }
  67.         flags:                    INTEGER;                                { volume mount flags. Variable length data follows }
  68.     END;
  69.  
  70.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  71.  
  72.  
  73. CONST
  74.     gestaltFSMVersion            = 'fsm ';
  75.  
  76.     
  77. TYPE
  78.     VCBPtr = ^VCB;
  79.  
  80. {
  81.  * Miscellaneous file system values not in Files.h
  82.  }
  83.  
  84. CONST
  85.     fsUsrCNID                    = 16;                            { First assignable directory or file number }
  86. {    File system trap word attribute bits }
  87.     kHFSBit                        = 9;                            { HFS call: bit 9 }
  88.     kHFSMask                    = $0200;
  89.     kAsyncBit                    = 10;                            { Asynchronous call: bit 10 }
  90.     kAsyncMask                    = $0400;
  91.  
  92. {
  93.  * HFSCIProc selectCode values
  94.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  95.  * may be set in these selectCode values.
  96.  }
  97.     kFSMOpen                    = $A000;
  98.     kFSMClose                    = $A001;
  99.     kFSMRead                    = $A002;
  100.     kFSMWrite                    = $A003;
  101.     kFSMGetVolInfo                = $A007;
  102.     kFSMCreate                    = $A008;
  103.     kFSMDelete                    = $A009;
  104.     kFSMOpenRF                    = $A00A;
  105.     kFSMRename                    = $A00B;
  106.     kFSMGetFileInfo                = $A00C;
  107.     kFSMSetFileInfo                = $A00D;
  108.     kFSMUnmountVol                = $A00E;
  109.     kFSMMountVol                = $A00F;
  110.     kFSMAllocate                = $A010;
  111.     kFSMGetEOF                    = $A011;
  112.     kFSMSetEOF                    = $A012;
  113.     kFSMFlushVol                = $A013;
  114.     kFSMGetVol                    = $A014;
  115.     kFSMSetVol                    = $A015;
  116.     kFSMEject                    = $A017;
  117.     kFSMGetFPos                    = $A018;
  118.     kFSMOffline                    = $A035;
  119.     kFSMSetFilLock                = $A041;
  120.     kFSMRstFilLock                = $A042;
  121.     kFSMSetFilType                = $A043;
  122.     kFSMSetFPos                    = $A044;
  123.     kFSMFlushFile                = $A045;
  124. {    The File System HFSDispatch selectCodes }
  125.     kFSMOpenWD                    = $0001;
  126.     kFSMCloseWD                    = $0002;
  127.     kFSMCatMove                    = $0005;
  128.     kFSMDirCreate                = $0006;
  129.     kFSMGetWDInfo                = $0007;
  130.     kFSMGetFCBInfo                = $0008;
  131.     kFSMGetCatInfo                = $0009;
  132.     kFSMSetCatInfo                = $000A;
  133.     kFSMSetVolInfo                = $000B;
  134.     kFSMLockRng                    = $0010;
  135.     kFSMUnlockRng                = $0011;
  136.     kFSMCreateFileIDRef            = $0014;
  137.     kFSMDeleteFileIDRef            = $0015;
  138.     kFSMResolveFileIDRef        = $0016;
  139.     kFSMExchangeFiles            = $0017;
  140.     kFSMCatSearch                = $0018;
  141.     kFSMOpenDF                    = $001A;
  142.     kFSMMakeFSSpec                = $001B;
  143. {    The Desktop Manager HFSDispatch selectCodes }
  144.     kFSMDTGetPath                = $0020;
  145.     kFSMDTCloseDown                = $0021;
  146.     kFSMDTAddIcon                = $0022;
  147.     kFSMDTGetIcon                = $0023;
  148.     kFSMDTGetIconInfo            = $0024;
  149.     kFSMDTAddAPPL                = $0025;
  150.     kFSMDTRemoveAPPL            = $0026;
  151.     kFSMDTGetAPPL                = $0027;
  152.     kFSMDTSetComment            = $0028;
  153.     kFSMDTRemoveComment            = $0029;
  154.     kFSMDTGetComment            = $002A;
  155.     kFSMDTFlush                    = $002B;
  156.     kFSMDTReset                    = $002C;
  157.     kFSMDTGetInfo                = $002D;
  158.     kFSMDTOpenInform            = $002E;
  159.     kFSMDTDelete                = $002F;
  160. {    The AppleShare HFSDispatch selectCodes }
  161.     kFSMGetVolParms                = $0030;
  162.     kFSMGetLogInInfo            = $0031;
  163.     kFSMGetDirAccess            = $0032;
  164.     kFSMSetDirAccess            = $0033;
  165.     kFSMMapID                    = $0034;
  166.     kFSMMapName                    = $0035;
  167.     kFSMCopyFile                = $0036;
  168.     kFSMMoveRename                = $0037;
  169.     kFSMOpenDeny                = $0038;
  170.     kFSMOpenRFDeny                = $0039;
  171.     kFSMGetXCatInfo                = $003A;
  172.     kFSMGetVolMountInfoSize        = $003F;
  173.     kFSMGetVolMountInfo            = $0040;
  174.     kFSMVolumeMount                = $0041;
  175.     kFSMShare                    = $0042;
  176.     kFSMUnShare                    = $0043;
  177.     kFSMGetUGEntry                = $0044;
  178.     kFSMGetForeignPrivs            = $0060;
  179.     kFSMSetForeignPrivs            = $0061;
  180.  
  181. {
  182.  * UTDetermineVol status values
  183.  }
  184.     dtmvError                    = 0;                            { param error }
  185.     dtmvFullPathame                = 1;                            { determined by full pathname }
  186.     dtmvVRefNum                    = 2;                            { determined by volume refNum }
  187.     dtmvWDRefNum                = 3;                            { determined by working directory refNum }
  188.     dtmvDriveNum                = 4;                            { determined by drive number }
  189.     dtmvDefault                    = 5;                            { determined by default volume }
  190.  
  191. {
  192.  * UTGetBlock options
  193.  }
  194.     gbDefault                    = 0;                            { default value - read if not found }
  195. {    bits and masks }
  196.     gbReadBit                    = 0;                            { read block from disk (forced read) }
  197.     gbReadMask                    = $0001;
  198.     gbExistBit                    = 1;                            { get existing cache block }
  199.     gbExistMask                    = $0002;
  200.     gbNoReadBit                    = 2;                            { don't read block from disk if not found in cache }
  201.     gbNoReadMask                = $0004;
  202.     gbReleaseBit                = 3;                            { release block immediately after GetBlock }
  203.     gbReleaseMask                = $0008;
  204.  
  205. {
  206.  * UTReleaseBlock options
  207.  }
  208.     rbDefault                    = 0;                            { default value - just mark the buffer not in-use }
  209. {    bits and masks }
  210.     rbWriteBit                    = 0;                            { force write buffer to disk }
  211.     rbWriteMask                    = $0001;
  212.     rbTrashBit                    = 1;                            { trash buffer contents after release }
  213.     rbTrashMask                    = $0002;
  214.     rbDirtyBit                    = 2;                            { mark buffer dirty }
  215.     rbDirtyMask                    = $0004;
  216.     rbFreeBit                    = 3;                            { free the buffer (save in the hash) }
  217. {
  218.  *    rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache;
  219.  *    on >= System 7.0, rbfreeMask overrides rbTrash
  220.  }
  221.     rbFreeMask                    = $000A;
  222.  
  223. {
  224.  * UTFlushCache options
  225.  }
  226.     fcDefault                    = 0;                            { default value - just flush any dirty buffers }
  227. {    bits and masks }
  228.     fcTrashBit                    = 1;                            { trash buffers after flushing }
  229.     fcTrashMask                    = $0002;
  230.     fcFreeBit                    = 3;                            { free buffers after flushing }
  231.     fcFreeMask                    = $0008;                        { fcFreeMask works as fcTrash on < System 7.0 RamCache }
  232.  
  233. {
  234.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  235.  }
  236.     noCacheBit                    = 5;                            { don't cache this please }
  237.     noCacheMask                    = $0020;
  238.     rdVerifyBit                    = 6;                            { read verify }
  239.     rdVerifyMask                = $0040;
  240.  
  241. {
  242.  * Cache routine internal error codes
  243.  }
  244.     chNoBuf                        = 1;                            { no free cache buffers (all in use) }
  245.     chInUse                        = 2;                            { requested block in use }
  246.     chnotfound                    = 3;                            { requested block not found }
  247.     chNotInUse                    = 4;                            { block being released was not in use }
  248.  
  249. {
  250.  * FCBRec.fcbFlags bits
  251.  }
  252.     fcbWriteBit                    = 0;                            { Data can be written to this file }
  253.     fcbWriteMask                = $01;
  254.     fcbResourceBit                = 1;                            { This file is a resource fork }
  255.     fcbResourceMask                = $02;
  256.     fcbWriteLockedBit            = 2;                            { File has a locked byte range }
  257.     fcbWriteLockedMask            = $04;
  258.     fcbSharedWriteBit            = 4;                            { File is open for shared write access }
  259.     fcbSharedWriteMask            = $10;
  260.     fcbFileLockedBit            = 5;                            { File is locked (write-protected) }
  261.     fcbFileLockedMask            = $20;
  262.     fcbOwnClumpBit                = 6;                            { File has clump size specified in FCB }
  263.     fcbOwnClumpMask                = $40;
  264.     fcbModifiedBit                = 7;                            { File has changed since it was last flushed }
  265.     fcbModifiedMask                = $80;
  266.  
  267. {
  268.  * ExtFileProc options
  269.  }
  270.     extendFileAllBit            = 0;                            { allocate all requested bytes or none }
  271.     extendFileAllMask            = $0001;
  272.     extendFileContigBit            = 1;                            { force contiguous allocation }
  273.     extendFileContigMask        = $0002;
  274.  
  275. {
  276.  *    HFS Component Interface constants
  277.  }
  278. {
  279.  * compInterfMask bits specific to HFS component
  280.  }
  281.     hfsCIDoesHFSBit                = 23;                            { set if file system supports HFS calls }
  282.     hfsCIDoesHFSMask            = $00800000;
  283.     hfsCIDoesAppleShareBit        = 22;                            { set if AppleShare calls supported }
  284.     hfsCIDoesAppleShareMask        = $00400000;
  285.     hfsCIDoesDeskTopBit            = 21;                            { set if Desktop Database calls supported }
  286.     hfsCIDoesDeskTopMask        = $00200000;
  287.     hfsCIDoesDynamicLoadBit        = 20;                            { set if dynamically loading code resource }
  288.     hfsCIDoesDynamicLoadMask    = $00100000;                    {        supported }
  289.     hfsCIResourceLoadedBit        = 19;                            { set if code resource already loaded }
  290.     hfsCIResourceLoadedMask        = $00080000;
  291.     hfsCIHasHLL2PProcBit        = 18;                            { set if FFS' log2PhyProc and Extendfile proc }
  292.     hfsCIHasHLL2PProcMask        = $00040000;                    { is written in a high level language. (i.e., uses Pascal calling convention) }
  293.  
  294. {
  295.  *    Disk Initialization Component Interface constants
  296.  }
  297. {
  298.  * compInterfMask bits specific to Disk Initialization component
  299.  }
  300.     diCIHasExtFormatParamsBit    = 18;                            { set if file system needs extended format }
  301.     diCIHasExtFormatParamsMask    = $00040000;                    {        parameters }
  302.     diCIHasMultiVolTypesBit        = 17;                            { set if file system supports more than one }
  303.     diCIHasMultiVolTypesMask    = $00020000;                    {        volume type }
  304.     diCIDoesSparingBit            = 16;                            { set if file system supports disk sparing }
  305.     diCIDoesSparingMask            = $00010000;
  306.     diCILiveBit                    = 0;                            { set if file system is candidate for current }
  307.     diCILiveMask                = $00000001;                    {        formatting operation (set by PACK2) }
  308.  
  309. {
  310.  * Disk Initialization Component Function selectors
  311.  }
  312.     diCILoad                    = 1;                            { Make initialization code memory resident }
  313.     diCIUnload                    = 2;                            { Make initialization code purgeable }
  314.     diCIEvaluateSizeChoices        = 3;                            { Evaluate size choices }
  315.     diCIExtendedZero            = 4;                            { Write an empty volume directory }
  316.     diCIValidateVolName            = 5;                            { Validate volume name }
  317.     diCIGetVolTypeInfo            = 6;                            { get volume type info }
  318.     diCIGetFormatString            = 7;                            { get dialog format string }
  319.     diCIGetExtFormatParams        = 8;                            { get extended format parameters }
  320.     diCIGetDefectList            = 9;                            { return the defect list for the indicated disk - reserved for future use }
  321.  
  322. {
  323.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  324.  }
  325.     diCIFmtListMax                = 8;                            { maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries }
  326. {    bits in FormatListRec.formatFlags: }
  327.     diCIFmtFlagsValidBit        = 7;                            { set if sec, side, tracks valid }
  328.     diCIFmtFlagsValidMask        = $80;
  329.     diCIFmtFlagsCurrentBit        = 6;                            { set if current disk has this fmt }
  330.     diCIFmtFlagsCurrentMask        = $40;
  331. {    bits in FormatListRec.sizeListFlags: }
  332.     diCISizeListOKBit            = 15;                            { set if this disk size usable }
  333.     diCISizeListOKMask            = $8000;
  334.  
  335. {
  336.  * DICIGetFormatStringRec.stringKind format strings
  337.  }
  338.     diCIAlternateFormatStr        = 1;                            { get alternate format  string (Balloon Help) }
  339.     diCISizePresentationStr        = 2;                            { get size presentation string (for dialog) }
  340.  
  341. {
  342.  * Error codes returned by Disk Sparing
  343.  }
  344.     diCIUserCancelErr            = 1;                            { user cancelled the disk init }
  345.     diCICriticalSectorBadErr    = 20;                            { critical sectors are bad (hopeless)    }
  346.     diCISparingFailedErr        = 21;                            { disk cannot be spared }
  347.     diCITooManyBadSectorsErr    = 22;                            { too many bad sectors }
  348.     diCIUnknownVolTypeErr        = 23;                            { the volume type passed in diCIExtendedZero paramBlock is not supported }
  349.     diCIVolSizeMismatchErr        = 24;                            { specified volume size doesn’t match with formatted disk size }
  350.     diCIUnknownDICallErr        = 25;                            { bogus DI function call selector }
  351.     diCINoSparingErr            = 26;                            { disk is bad but the target FS doesn't do disk sparing }
  352.     diCINoExtendInfoErr            = 27;                            { missing file system specific extra parameter in diCIExtendedZero call }
  353.     diCINoMessageTextErr        = 28;                            { missing message text in DIReformat call }
  354.  
  355. {
  356.  *    File System Manager constants
  357.  }
  358. {
  359.  * Miscellaneous constants used by FSM
  360.  }
  361.     fsdVersion1                    = 1;                            { current version of FSD record }
  362.     fsmIgnoreFSID                = $fffe;                        { this FSID should be ignored by the driver }
  363.     fsmGenericFSID                = $ffff;                        { unknown foreign file system ID }
  364.  
  365. {
  366.  * compInterfMask bits common to all FSM components
  367.  }
  368.     fsmComponentEnableBit        = 31;                            { set if FSM component interface is enabled }
  369.     fsmComponentEnableMask        = $80000000;
  370.     fsmComponentBusyBit            = 30;                            { set if FSM component interface is busy }
  371.     fsmComponentBusyMask        = $40000000;
  372.  
  373. {
  374.  * Selectors for GetFSInfo
  375.  }
  376.     fsmGetFSInfoByIndex            = -1;                            { get fs info by index }
  377.     fsmGetFSInfoByFSID            = 0;                            { get fs info by FSID }
  378.     fsmGetFSInfoByRefNum        = 1;                            { get fs info by file/vol refnum }
  379.  
  380. {
  381.  * InformFSM messages
  382.  }
  383.     fsmNopMessage                = 0;                            { nop }
  384.     fsmDrvQElChangedMessage        = 1;                            { DQE has changed }
  385.     fsmGetFSIconMessage            = 2;                            { Get FFS's disk icon }
  386.  
  387. {
  388.  * Messages passed to the fileSystemCommProc
  389.  }
  390.     ffsNopMessage                = 0;                            { nop, should always return noErr }
  391.     ffsGetIconMessage            = 1;                            { return disk icon and mask }
  392.     ffsIDDiskMessage            = 2;                            { identify the about-to-be-mounted volume }
  393.     ffsLoadMessage                = 3;                            { load in the FFS }
  394.     ffsUnloadMessage            = 4;                            { unload the FFS }
  395.     ffsIDVolMountMessage        = 5;                            { identify a VolMountInfo record }
  396.     ffsInformMessage            = 6;                            { FFS defined message }
  397.     ffsGetIconInfoMessage        = 7;
  398.  
  399. {
  400.  * Error codes from FSM functions
  401.  }
  402.     fsmFFSNotFoundErr            = -431;                            { Foreign File system does not exist - new Pack2 could return this error too }
  403.     fsmBusyFFSErr                = -432;                            { File system is busy, cannot be removed }
  404.     fsmBadFFSNameErr            = -433;                            { Name length not 1 <= length <= 31 }
  405.     fsmBadFSDLenErr                = -434;                            { FSD size incompatible with current FSM vers }
  406.     fsmDuplicateFSIDErr            = -435;                            { FSID already exists on InstallFS }
  407.     fsmBadFSDVersionErr            = -436;                            { FSM version incompatible with FSD }
  408.     fsmNoAlternateStackErr        = -437;                            { no alternate stack for HFS CI }
  409.     fsmUnknownFSMMessageErr        = -438;                            { unknown message passed to FSM }
  410.  
  411. {
  412.  *    HFS Utility routine records
  413.  }
  414. {
  415.  * record used by UTGetPathComponentName
  416.  }
  417.  
  418. TYPE
  419.     ParsePathRec = RECORD
  420.         namePtr:                StringPtr;                                { pathname to parse }
  421.         startOffset:            INTEGER;                                { where to start parsing }
  422.         componentLength:        INTEGER;                                { the length of the pathname component parsed }
  423.         moreName:                SignedByte;                                { non-zero if there are more components after this one }
  424.         foundDelimiter:            SignedByte;                                { non-zero if parsing stopped because a colon (:) delimiter was found }
  425.     END;
  426.  
  427.     ParsePathRecPtr = ^ParsePathRec;
  428.  
  429.     WDCBRec = RECORD
  430.         wdVCBPtr:                VCBPtr;                                    { Pointer to VCB of this working directory }
  431.         wdDirID:                LONGINT;                                { Directory ID number of this working directory }
  432.         wdCatHint:                LONGINT;                                { Hint for finding this working directory }
  433.         wdProcID:                LONGINT;                                { Process that created this working directory }
  434.     END;
  435.  
  436.     WDCBRecPtr = ^WDCBRec;
  437.  
  438.     FCBRec = RECORD
  439.         fcbFlNm:                LONGINT;                                { FCB file number. Non-zero marks FCB used }
  440.         fcbFlags:                SignedByte;                                { FCB flags }
  441.         fcbTypByt:                SignedByte;                                { File type byte }
  442.         fcbSBlk:                INTEGER;                                { File start block (in alloc size blks) }
  443.         fcbEOF:                    LONGINT;                                { Logical length or EOF in bytes }
  444.         fcbPLen:                LONGINT;                                { Physical file length in bytes }
  445.         fcbCrPs:                LONGINT;                                { Current position within file }
  446.         fcbVPtr:                VCBPtr;                                    { Pointer to the corresponding VCB }
  447.         fcbBfAdr:                Ptr;                                    { File's buffer address }
  448.         fcbFlPos:                INTEGER;                                { Directory block this file is in }
  449.         { FCB Extensions for HFS }
  450.         fcbClmpSize:            LONGINT;                                { Number of bytes per clump }
  451.         fcbBTCBPtr:                Ptr;                                    { Pointer to B*-Tree control block for file }
  452.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                { First 3 file extents }
  453.         fcbFType:                OSType;                                    { File's 4 Finder Type bytes }
  454.         fcbCatPos:                LONGINT;                                { Catalog hint for use on Close }
  455.         fcbDirID:                LONGINT;                                { Parent Directory ID }
  456.         fcbCName:                Str31;                                    { CName of open file }
  457.     END;
  458.  
  459.     FCBRecPtr = ^FCBRec;
  460.  
  461. {
  462.  *    HFS Component Interface records
  463.  }
  464.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  465.     Lg2PhysUPP = UniversalProcPtr;
  466.  
  467. CONST
  468.     uppLg2PhysProcInfo = $003FEFE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  469.  
  470. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  471.     {$IFC NOT GENERATINGCFM }
  472.     INLINE $2E9F;
  473.     {$ENDC}
  474.  
  475. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $205F, $4E90;
  478.     {$ENDC}
  479. TYPE
  480.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  481.     HFSCIUPP = UniversalProcPtr;
  482.  
  483. CONST
  484.     uppHFSCIProcInfo = $0000BEE0; { FUNCTION (4 byte param, 2 byte param, 4 byte param, 4 byte param, 2 byte param): 2 byte result; }
  485.  
  486. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  487.     {$IFC NOT GENERATINGCFM }
  488.     INLINE $2E9F;
  489.     {$ENDC}
  490.  
  491. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  492.     {$IFC NOT GENERATINGCFM}
  493.     INLINE $205F, $4E90;
  494.     {$ENDC}
  495.  
  496. TYPE
  497.     HFSCIRec = RECORD
  498.         compInterfMask:            LONGINT;                                { component flags }
  499.         compInterfProc:            HFSCIUPP;                                { pointer to file system call processing code }
  500.         log2PhyProc:            Lg2PhysUPP;                                { pointer to Lg2PhysProc() code }
  501.         stackTop:                Ptr;                                    { file system stack top }
  502.         stackSize:                LONGINT;                                { file system stack size }
  503.         stackPtr:                Ptr;                                    { current file system stack pointer }
  504.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  505.         idSector:                LONGINT;                                { Sector you need to ID a local volume. For networked volumes, this must be -1 }
  506.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  507.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  508.     END;
  509.  
  510.     HFSCIRecPtr = ^HFSCIRec;
  511.  
  512. {
  513.  *    Disk Initialization Component Interface records
  514.  }
  515.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  516.     DICIUPP = UniversalProcPtr;
  517.  
  518. CONST
  519.     uppDICIProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  520.  
  521. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  522.     {$IFC NOT GENERATINGCFM }
  523.     INLINE $2E9F;
  524.     {$ENDC}
  525.  
  526. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  527.     {$IFC NOT GENERATINGCFM}
  528.     INLINE $205F, $4E90;
  529.     {$ENDC}
  530.  
  531. TYPE
  532.     DICIRec = RECORD
  533.         compInterfMask:            LONGINT;                                { component flags }
  534.         compInterfProc:            DICIUPP;                                { pointer to call processing code }
  535.         maxVolNameLength:        INTEGER;                                { maximum length of your volume name }
  536.         blockSize:                INTEGER;                                { your file system's block size }
  537.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  538.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  539.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  540.     END;
  541.  
  542.     DICIRecPtr = ^DICIRec;
  543.  
  544. {
  545.  * FormatListRec as returned by the .Sony disk driver's
  546.  * Return Format List status call (csCode = 6).
  547.  * If the status call to get this list for a drive is not
  548.  * implemented by the driver, then a list with one entry
  549.  * is contructed from the drive queue element for the drive.
  550.  }
  551.     FormatListRec = RECORD
  552.         volSize:                LONGINT;                                { disk capacity in SECTORs }
  553.         formatFlags:            SignedByte;                                { flags }
  554.         sectorsPerTrack:        SignedByte;                                { sectors per track side }
  555.         tracks:                    INTEGER;                                { number of tracks }
  556.     END;
  557.  
  558.     FormatListRecPtr = ^FormatListRec;
  559.  
  560. {
  561.  * SizeListRec built from FormatListRecs as described above.
  562.  }
  563.     SizeListRec = RECORD
  564.         sizeListFlags:            INTEGER;                                { flags as set by external file system }
  565.         sizeEntry:                FormatListRec;                            { disk driver format list record }
  566.     END;
  567.  
  568.     SizeListRecPtr = ^SizeListRec;
  569.  
  570. {
  571.  * paramBlock for the diCIEvaluateSize call
  572.  }
  573.     DICIEvaluateSizeRec = RECORD
  574.         defaultSizeIndex:        INTEGER;                                { default size for this FS }
  575.         numSizeEntries:            INTEGER;                                { number of size entries }
  576.         driveNumber:            INTEGER;                                { drive number }
  577.         sizeListPtr:            SizeListRecPtr;                            { ptr to size entry table }
  578.         sectorSize:                INTEGER;                                { bytes per sector }
  579.     END;
  580.  
  581.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  582.  
  583. {
  584.  * paramBlock for the diCIExtendedZero call
  585.  }
  586.     DICIExtendedZeroRec = RECORD
  587.         driveNumber:            INTEGER;                                { drive number }
  588.         volNamePtr:                StringPtr;                                { ptr to volume name string }
  589.         fsid:                    INTEGER;                                { file system ID }
  590.         volTypeSelector:        INTEGER;                                { volume type selector, if supports more than 1 type }
  591.         numDefectBlocks:        INTEGER;                                { number of bad logical blocks }
  592.         defectListSize:            INTEGER;                                { size of the defect list buffer in bytes }
  593.         defectListPtr:            Ptr;                                    { pointer to defect list buffer }
  594.         volSize:                LONGINT;                                { size of volume in SECTORs }
  595.         sectorSize:                INTEGER;                                { bytes per sector }
  596.         extendedInfoPtr:        Ptr;                                    { ptr to extended info }
  597.     END;
  598.  
  599.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  600.  
  601. {
  602.  * paramBlock for the diCIValidateVolName call
  603.  }
  604.     DICIValidateVolNameRec = PACKED RECORD
  605.         theChar:                CHAR;                                    { the character to validate }
  606.         hasMessageBuffer:        BOOLEAN;                                { false if no message }
  607.         charOffset:                INTEGER;                                { position of the current character (first char = 1) }
  608.         messageBufferPtr:        StringPtr;                                { pointer to message buffer or nil }
  609.         charByteType:            INTEGER;                                { theChar's byte type (smSingleByte, smFirstByte, or smLastByte) }
  610.     END;
  611.  
  612.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  613.  
  614. {
  615.  * paramBlock for the diCIGetVolTypeInfo call
  616.  }
  617.     DICIGetVolTypeInfoRec = RECORD
  618.         volSize:                LONGINT;                                { size of volume in SECTORs }
  619.         sectorSize:                INTEGER;                                { bytes per sector }
  620.         numVolTypes:            INTEGER;                                { number of volume types supported }
  621.         volTypesBuffer:            ARRAY [0..3] OF Str31;                    { 4 string buffers }
  622.     END;
  623.  
  624.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  625.  
  626. {
  627.  * paramBlock for the diCIGetFormatString call
  628.  }
  629.     DICIGetFormatStringRec = RECORD
  630.         volSize:                LONGINT;                                { volume size in SECTORs }
  631.         sectorSize:                INTEGER;                                { sector size }
  632.         volTypeSelector:        INTEGER;                                { volume type selector }
  633.         stringKind:                INTEGER;                                { sub-function = type of string }
  634.         stringBuffer:            Str255;                                    { string buffer }
  635.     END;
  636.  
  637.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  638.  
  639. {
  640.  * paramBlock for the diCIGetExtendedFormatParams call
  641.  }
  642.     DICIGetExtendedFormatRec = RECORD
  643.         driveNumber:            INTEGER;                                { drive number }
  644.         volTypeSelector:        INTEGER;                                { volume type selector or 0 }
  645.         volSize:                LONGINT;                                { size of volume in SECTORs }
  646.         sectorSize:                INTEGER;                                { bytes per sector }
  647.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to the foreign file system's FSSpec }
  648.         extendedInfoPtr:        Ptr;                                    { pointer to extended parameter structure }
  649.     END;
  650.  
  651.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  652.  
  653. {
  654.  *    File System Manager records
  655.  }
  656.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  657.     FSDCommUPP = UniversalProcPtr;
  658.  
  659. CONST
  660.     uppFSDCommProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  661.  
  662. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  663.     {$IFC NOT GENERATINGCFM }
  664.     INLINE $2E9F;
  665.     {$ENDC}
  666.  
  667. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  668.     {$IFC NOT GENERATINGCFM}
  669.     INLINE $205F, $4E90;
  670.     {$ENDC}
  671.  
  672. TYPE
  673.     FSDRec = RECORD
  674.         fsdLink:                ^FSDRec;                                { ptr to next }
  675.         fsdLength:                INTEGER;                                { length of this FSD in BYTES }
  676.         fsdVersion:                INTEGER;                                { version number }
  677.         fileSystemFSID:            INTEGER;                                { file system id }
  678.         fileSystemName:            Str31;                                    { file system name }
  679.         fileSystemSpec:            FSSpec;                                    { foreign file system's FSSpec }
  680.         fileSystemGlobalsPtr:    Ptr;                                    { ptr to file system globals }
  681.         fileSystemCommProc:        FSDCommUPP;                                { communication proc with the FFS }
  682.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  683.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  684.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  685.         fsdHFSCI:                HFSCIRec;                                { HFS component interface    }
  686.         fsdDICI:                DICIRec;                                { Disk Initialization component interface }
  687.     END;
  688.  
  689.     FSDRecPtr = ^FSDRec;
  690.  
  691.     FSMGetIconInfoRec = RECORD
  692.         theIcon:                ARRAY [0..31] OF LONGINT;                { The ICN# structure }
  693.         theMask:                ARRAY [0..31] OF LONGINT;                { The mask for the icon above }
  694.         whereStr:                Str255;
  695.     END;
  696.  
  697.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  698.  
  699. {
  700.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  701.  }
  702.     FSMGetIconRec = RECORD
  703.         refNum:                    INTEGER;                                { target drive num or volume refnum }
  704.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    { pointer to icon buffer }
  705.         requestSize:            LONGINT;                                { requested size of the icon buffer }
  706.         actualSize:                LONGINT;                                { actual size of the icon data returned }
  707.         iconType:                SInt8;                                    { kind of icon }
  708.         isEjectable:            BOOLEAN;                                { true if the device is ejectable }
  709.         driveQElemPtr:            DrvQElPtr;                                { pointer to DQE }
  710.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to foreign file system's FSSpec }
  711.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  712.     END;
  713.  
  714.     FSMGetIconRecPtr = ^FSMGetIconRec;
  715.  
  716. {
  717.  *    HFS Utility routine prototypes
  718.  }
  719.  
  720. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  721.     {$IFC NOT GENERATINGCFM}
  722.     INLINE $7000, $A824;
  723.     {$ENDC}
  724. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  725.     {$IFC NOT GENERATINGCFM}
  726.     INLINE $7001, $A824;
  727.     {$ENDC}
  728. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  729.     {$IFC NOT GENERATINGCFM}
  730.     INLINE $7002, $A824;
  731.     {$ENDC}
  732. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  733.     {$IFC NOT GENERATINGCFM}
  734.     INLINE $7003, $A824;
  735.     {$ENDC}
  736. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $7004, $A824;
  739.     {$ENDC}
  740. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $7005, $A824;
  743.     {$ENDC}
  744. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $7006, $A824;
  747.     {$ENDC}
  748. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $7007, $A824;
  751.     {$ENDC}
  752. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $7008, $A824;
  755.     {$ENDC}
  756. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $7009, $A824;
  759.     {$ENDC}
  760. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $700A, $A824;
  763.     {$ENDC}
  764. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $700B, $A824;
  767.     {$ENDC}
  768. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $700C, $A824;
  771.     {$ENDC}
  772. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $700D, $A824;
  775.     {$ENDC}
  776. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  777.     {$IFC NOT GENERATINGCFM}
  778.     INLINE $700E, $A824;
  779.     {$ENDC}
  780. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  781.     {$IFC NOT GENERATINGCFM}
  782.     INLINE $700F, $A824;
  783.     {$ENDC}
  784. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  785.     {$IFC NOT GENERATINGCFM}
  786.     INLINE $7010, $A824;
  787.     {$ENDC}
  788. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  789.     {$IFC NOT GENERATINGCFM}
  790.     INLINE $7011, $A824;
  791.     {$ENDC}
  792. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  793.     {$IFC NOT GENERATINGCFM}
  794.     INLINE $7012, $A824;
  795.     {$ENDC}
  796. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  797.     {$IFC NOT GENERATINGCFM}
  798.     INLINE $702B, $A824;
  799.     {$ENDC}
  800. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  801.     {$IFC NOT GENERATINGCFM}
  802.     INLINE $7013, $A824;
  803.     {$ENDC}
  804. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $7014, $A824;
  807.     {$ENDC}
  808. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  809.     {$IFC NOT GENERATINGCFM}
  810.     INLINE $7015, $A824;
  811.     {$ENDC}
  812. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  813.     {$IFC NOT GENERATINGCFM}
  814.     INLINE $7016, $A824;
  815.     {$ENDC}
  816. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  817.     {$IFC NOT GENERATINGCFM}
  818.     INLINE $7017, $A824;
  819.     {$ENDC}
  820. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  821.     {$IFC NOT GENERATINGCFM}
  822.     INLINE $7018, $A824;
  823.     {$ENDC}
  824. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  825.     {$IFC NOT GENERATINGCFM}
  826.     INLINE $7019, $A824;
  827.     {$ENDC}
  828. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  829.     {$IFC NOT GENERATINGCFM}
  830.     INLINE $701A, $A824;
  831.     {$ENDC}
  832. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  833.     {$IFC NOT GENERATINGCFM}
  834.     INLINE $701B, $A824;
  835.     {$ENDC}
  836. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  837.     {$IFC NOT GENERATINGCFM}
  838.     INLINE $701C, $A824;
  839.     {$ENDC}
  840. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  841.     {$IFC NOT GENERATINGCFM}
  842.     INLINE $701D, $A824;
  843.     {$ENDC}
  844. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  845.     {$IFC NOT GENERATINGCFM}
  846.     INLINE $701F, $A824;
  847.     {$ENDC}
  848. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  849.     {$IFC NOT GENERATINGCFM}
  850.     INLINE $7020, $A824;
  851.     {$ENDC}
  852. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  853.     {$IFC NOT GENERATINGCFM}
  854.     INLINE $7021, $A824;
  855.     {$ENDC}
  856. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  857.     {$IFC NOT GENERATINGCFM}
  858.     INLINE $7023, $A824;
  859.     {$ENDC}
  860. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  861.     {$IFC NOT GENERATINGCFM}
  862.     INLINE $7024, $A824;
  863.     {$ENDC}
  864. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  865.     {$IFC NOT GENERATINGCFM}
  866.     INLINE $7025, $A824;
  867.     {$ENDC}
  868. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  869.     {$IFC NOT GENERATINGCFM}
  870.     INLINE $7026, $A824;
  871.     {$ENDC}
  872. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  873.     {$IFC NOT GENERATINGCFM}
  874.     INLINE $7027, $A824;
  875.     {$ENDC}
  876. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  877.     {$IFC NOT GENERATINGCFM}
  878.     INLINE $7028, $A824;
  879.     {$ENDC}
  880. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  881.     {$IFC NOT GENERATINGCFM}
  882.     INLINE $702C, $A824;
  883.     {$ENDC}
  884. {
  885.  *    File System Manager call prototypes
  886.  }
  887. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  888. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  889. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  890. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  891. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  892. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  893.  
  894. {$ALIGN RESET}
  895. {$POP}
  896.  
  897. {$SETC UsingIncludes := FSMIncludes}
  898.  
  899. {$ENDC} {__FSM__}
  900.  
  901. {$IFC NOT UsingIncludes}
  902.  END.
  903. {$ENDC}
  904.